package com.yztstudy.Service.Impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yztstudy.Mapper.CategoryMapper;
import com.yztstudy.Service.CategoryService;
import com.yztstudy.clients.ProductFeignClient;
import com.yztstudy.entity.Category;
import com.yztstudy.param.PageParam;
import com.yztstudy.param.ProductHotParam;
import com.yztstudy.utils.R;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.List;

@Service
@Slf4j
public class CategoryServiceImpl implements CategoryService {

    @Autowired
    private CategoryMapper categoryMapper;

    @Resource
    private ProductFeignClient productFeignClient;

    /**
     * TODO 根据种类名查询主键
     * @param categoryName 类别名称
     * @return
     */
    @Override
    public R byName(String categoryName) {

        // TODO 1.在数据库中查询
        QueryWrapper<Category> wrapper = new QueryWrapper<>();
        wrapper.eq("category_name", categoryName);
        Category category = categoryMapper.selectOne(wrapper);

        // TODO 2.结果判断
        if (category == null)
        {
            log.info("CategoryServiceImpl.byName业务结束, 结果:{}", "类别查询失败!");
            return R.fail("类别查询失败!");
        }

        // TODO 3.查询成功
        log.info("CategoryServiceImpl.byName业务结束, 结果:{}", "类别查询成功!");
        return R.ok("类别查询成功!", category);
    }


    /**
     * TODO 热门商品的ID查询
     * @param productHotParam 前端发过来的热门商品名称集合
     * @return
     */
    @Override
    public R hots(ProductHotParam productHotParam) {

        // TODO 1.在数据库中查询
        QueryWrapper<Category> wrapper = new QueryWrapper<>();
        wrapper.in("category_name", productHotParam.getCategoryName()); // 相当于where name in (...)
        wrapper.select("category_id");
        List<Object> objects = categoryMapper.selectObjs(wrapper);

        // TODO 2.返回结果
        log.info("CategoryServiceImpl.hots业务结束, 结果:{}", "多类别查询成功!");
        return R.ok("多类别查询成功!", objects);
    }


    /**
     * TODO 查询所有的类别
     * @return
     */
    @Override
    public R list() {

        // TODO 1.直接查询数据库
        List<Category> categories = categoryMapper.selectList(null);

        // TODO 2.返回结果
        log.info("CategoryServiceImpl.list业务结束, 结果:{}", "类别全部查询成功!");
        return R.ok("类别全部查询成功!", categories);
    }


    /**
     * TODO 分页查询种类
     * @param pageParam 分页参数
     * @return
     */
    @Override
    public R listPage(PageParam pageParam) {

        // TODO 1.构造分页条件
        IPage<Category> page = new Page<>(pageParam.getCurrentPage(), pageParam.getPageSize());

        // TODO 2.查询
        List<Category> result = categoryMapper.selectPage(page, null).getRecords();
        long total = page.getTotal();

        // TODO 3.返回数据
        log.info("CategoryServiceImpl.listPage业务结束, 结果:{}", "类别分页查询成功!");
        return R.ok("类别分页查询成功!", result, total);
    }


    /**
     * TODO 新增分类
     * @param category 分类对象
     * @return
     */
    @Transactional
    @Override
    public R saveCategory(Category category) {

        // TODO 1.判断类别名称是否存在
        QueryWrapper<Category> wrapper = new QueryWrapper<>();
        wrapper.eq("category_name", category.getCategoryName());
        Long count = categoryMapper.selectCount(wrapper);

        // TODO 2.如果存在
        if (count > 0)
        {
            return R.fail("类别已经存在,添加失败!");
        }

        // TODO 3.如果不存在
        categoryMapper.insert(category);
        log.info("CategoryServiceImpl.saveCategory业务结束, 结果:{}", "类别新增成功!");
        return R.ok("类别新增成功!");
    }


    /**
     * TODO 删除类别
     * @param categoryId 类别Id
     * @return
     */
    @Transactional
    @Override
    public R adminRemove(Integer categoryId) {

        // TODO 1.调用远程服务，看看是否有商品
        Long count = productFeignClient.adminCount(categoryId);

        // TODO 2.判断
        if (count > 0) // 有商品
        {
            log.info("CategoryServiceImpl.adminRemove业务结束, 结果:{}", "类别中存在商品,不可以删除!");
            return R.fail("类别中存在商品,不可以删除!");
        }

        else { // 没有商品
            categoryMapper.deleteById(categoryId);
            log.info("CategoryServiceImpl.adminRemove业务结束, 结果:{}", "类别中不存在商品,可以删除!");
            return R.ok("类别中不存在商品,可以删除!");
        }
    }


    /**
     * TODO 更新类别
     * @param category 类别对象
     * @return
     */
    @Transactional
    @Override
    public R adminUpdate(Category category) {

        // TODO 1.先判断类别名称是否重复
        QueryWrapper<Category> wrapper = new QueryWrapper<>();
        wrapper.eq("category_name", category.getCategoryName());
        Long count = categoryMapper.selectCount(wrapper);

        // TODO 2.如果重复了
        if (count > 0)
        {
            log.info("CategoryServiceImpl.adminUpdate业务结束, 结果:{}", "类别已经存在了,不可以修改!");
            return R.fail("类别已经存在了,不可以修改!");
        }

        // TODO 3.如果没有重复
        categoryMapper.updateById(category);
        log.info("CategoryServiceImpl.adminUpdate业务结束, 结果:{}", "类别不存在,可以修改!");
        return R.ok("类别不存在,可以修改!");
    }
}
